Hur kan jag ta bort ett visst objekt från en matris?

1
2
3
4
Nästa
Hitta indexet för arrayelementet du vill ta bort med indexOf och ta sedan bort indexet med splice.
Metoden splice () ändrar innehållet i en matris genom att ta bort
befintliga element och / eller lägga till nya element.
const array = [2, 5, 9];
console.log (array);
const index = array.indexOf (5);
om (index> -1) {
array.splice (index, 1);
}
// array = [2, 9]
console.log (array);
Den andra parametern för skarvning är antalet element som ska tas bort. Observera att skarvning ändrar matrisen på plats och returnerar en ny matris som innehåller de element som har tagits bort.
För fullständighetens skull finns här funktioner. Den första funktionen tar bara bort en enda förekomst (dvs. tar bort den första matchningen av 5 från [2,5,9,1,5,8,5]), medan den andra funktionen tar bort alla förekomster:
funktion removeItemOnce (arr, värde) {
var index = arr.indexOf (värde);
om (index> -1) {
arr.splice (index, 1);
}
retur arr;
}
funktion removeItemAll (arr, värde) {
var i = 0;
medan (i  = 0; i--) {
if (array [i] === nummer) {
array.splice (i, 1);
}
}
Om du bara vill göra elementet i index finns det inte längre, men du vill inte att indexen för de andra elementen ska ändras:
radera array [i];
|
Redigerad 2016 oktober
Gör det enkelt, intuitivt och tydligt (Occams rakhyvel)
Gör det oföränderligt (originaluppsättningen förblir oförändrad)
Gör det med vanliga JavaScript-funktioner, om din webbläsare inte stöder dem - använd polyfill
I detta kodexempel använder jag funktionen "array.filter (...)" för att ta bort oönskade objekt från en array. Denna funktion ändrar inte den ursprungliga matrisen och skapar en ny. Om din webbläsare inte stöder den här funktionen (t.ex. Internet Explorer före version 9 eller Firefox före version 1.5), överväg att använda filterpolyfyllningen från Mozilla.
Tar bort objekt (ECMA-262 Edition 5-kod aka oldstyle JavaScript)
var värde = 3
var arr = [1, 2, 3, 4, 5, 3]
arr = arr.filter (funktion (artikel) {
returnera artikel! == värde
})
console.log (arr)
// [1, 2, 4, 5]
Ta bort objekt (ECMAScript 6-kod)
låt värde = 3
låt arr = [1, 2, 3, 4, 5, 3]
arr = arr.filter (artikel => artikel! == värde)
console.log (arr)
// [1, 2, 4, 5]
VIKTIGT ECMAScript 6 "() => {}" syntax för pilfunktion stöds inte alls i Internet Explorer, Chrome före 45-version, Firefox före 22-version och Safari före 10-version. För att använda ECMAScript 6-syntax i gamla webbläsare kan du använda BabelJS.
Ta bort flera objekt (ECMAScript 7-kod)
En ytterligare fördel med den här metoden är att du kan ta bort flera objekt
let forDeletion = [2, 3, 5]
låt arr = [1, 2, 3, 4, 5, 3]
arr = arr.filter (item =>! forDeletion.includes (item))
// !!! Läs nedan om array.includes (...) support !!!
console.log (arr)
// [1, 4]
VIKTIGT funktionen "array.includes (...)" stöds inte i Internet Explorer alls, Chrome före 47-versionen, Firefox före 43-versionen, Safari före 9-versionen och Edge före 14-versionen, så här är polyfill från Mozilla.
Ta bort flera objekt (i framtiden, kanske)
Om förslaget "Denna bindande syntax" någonsin accepteras kan du göra detta:
// array-lib.js
exportfunktion ta bort (... forDeletion) {
returnera detta.filter (artikel =>! för borttagning.inkluderar (artikel))
}
// main.js
importera {remove} från './array-lib.js'
låt arr = [1, 2, 3, 4, 5, 3]
// :: Detta bindande syntaxförslag
// använder "ta bort" -funktionen som "virtuell metod"
// utan att förlänga Array.prototype
arr = arr :: ta bort (2, 3, 5)
console.log (arr)
// [1, 4]
Prova själv i BabelJS :)
Referens
Array.prototype.includes
Funktionell komposition
|
Det beror på om du vill behålla en tom plats eller inte.
Om du vill ha en tom plats:
array [index] = odefinierad;
Om du inte vill ha en tom plats:
// För att behålla originalet:
// oldArray = [... array];
// Detta ändrar arrayen.
array.splice (index, 1);
Och om du behöver värdet på det objektet kan du bara lagra den returnerade matrisens element:
var värde = array.splice (index, 1) [0];
Om du vill ta bort i endera änden av matrisen kan du använda array.pop () för den sista eller array.shift () för den första (båda returnerar också värdet på artikeln).
Om du inte känner till artikelns index kan du använda array.indexOf (item) för att hämta det (i ett if () för att få ett objekt eller ett tag () för att få dem alla). array.indexOf (artikel) returnerar antingen indexet eller -1 om det inte hittas.
|
En vän hade problem i Internet Explorer 8 och visade mig vad han gjorde. Jag sa till honom att det var fel och han sa att han fick svarethär. Det aktuella toppsvaret fungerar inte i alla webbläsare (till exempel Internet Explorer 8) och det tar bara bort den första förekomsten av artikeln.
Ta bort ALLA instanser från en matris
funktion array_remove_index_by_value (arr, artikel)
{
för (var i = arrlängd; i--;)
{
if (arr [i] === artikel) {arr.splice (i, 1);}
}
}
Den slingrar sig genom matrisen bakåt (eftersom index och längd ändras när objekt tas bort) och tar bort objektet om det hittas. Det fungerar i alla webbläsare.
|
Det finns två huvudmetoder:
skarv (): anArray.splice (index, 1);
ta bort: ta bort anArray [index];
Var försiktig när du använder delete för en matris. Det är bra för att ta bort attribut för objekt, men inte så bra för matriser. Det är bättre att använda skarv för matriser.
Tänk på att när du använder delete för en matris kan du få fel resultat för anArray.length. Med andra ord, ta bort elementet, men det uppdaterar inte värdet på längdegenskapen.
Du kan också räkna med att ha hål i indexnummer efter att du har tagit bort, t.ex. du kan sluta med att ha index 1, 3, 4, 8, 9 och 11 och längden som den var innan du tog bort. I så fall skulle alla indexerade för loopar krascha, eftersom index inte längre är sekventiella.
Om du tvingas använda delete av någon anledning bör du använda för varje slingor när du behöver gå igenom matriser. I själva verket, undvik alltid att använda indexerad för loopar, om möjligt. På så sätt skulle koden vara mer robust och mindre benägen för problem med index.
|
Array.prototype.remove_by_value = funktion (val) {
för (var i = 0; i  rad.id === 5);
var borttagen = helper.remove (arr, rad => row.name.startsWith ('BMW'));
##Definition
var hjälpar = {
// Ta bort och returnera den första förekomsten
removeOne: funktion (array, predikat) {
för (var i = 0; i  [2, 3, 4]
|
Du kan använda ES6. Till exempel för att ta bort värdet '3' i detta fall:
var array = ['1', '2', '3', '4', '5', '6']
var newArray = array.filter ((värde) => värde! = '3');
console.log (newArray);
Utgång:
["1", "2", "4", "5", "6"]
|
Om du vill ha en ny matris med borttagna positioner kan du alltid ta bort det specifika elementet och filtrera bort matrisen. Det kan behöva en förlängning av arrayobjektet för webbläsare som inte implementerar filtermetoden, men på lång sikt är det lättare eftersom allt du gör är detta:
var my_array = [1, 2, 3, 4, 5, 6];
ta bort min_array [4];
console.log (my_array.filter (funktion (a) {return typeof a! == 'odefinierad';}));
Den ska visa [1, 2, 3, 4, 6].
|
Här är några sätt att ta bort ett objekt från en matris med JavaScript.
Alla beskrivna metoder muterar inte den ursprungliga matrisen utan skapar istället en ny.
Om du vet indexet för en artikel
Antag att du har en matris och att du vill ta bort ett objekt i position i.
En metod är att använda slice ():
const items = ['a', 'b', 'c', 'd', 'e', ​​'f']
konst i = 3
const filteredItems = items.slice (0, i) .concat (items.slice (i + 1, items.length))
console.log (filteredItems)
slice () skapar en ny matris med de index som den får. Vi skapar helt enkelt en ny matris, från början till det index som vi vill ta bort, och sammanfogar en annan matris från första positionen efter den vi tog bort till slutet av matrisen.
Om du vet värdet
I det här fallet är ett bra alternativ att använda filter (), som erbjuder en mer deklarativ metod:
const items = ['a', 'b', 'c', 'd', 'e', ​​'f']
const valueToRemove = 'c'
const filteredItems = items.filter (item => item! == valueToRemove)
console.log (filteredItems)
Detta använder ES6-pilfunktionerna. Du kan använda de traditionella funktionerna för att stödja äldre webbläsare:
const items = ['a', 'b', 'c', 'd', 'e', ​​'f']
const valueToRemove = 'c'
const filteredItems = items.filter (funktion (artikel) {
returnera artikel! == valueToRemove
})
console.log (filteredItems)
eller så kan du använda Babel och transponera ES6-koden tillbaka till ES5 för att göra den mer smältbar för gamla webbläsare, men skriv modern JavaScript i din kod.
Ta bort flera objekt
Vad händer om du istället för ett enda objekt vill ta bort många objekt?
Låt oss hitta den enklaste lösningen.
Efter index
Du kan bara skapa en funktion och ta bort objekt i serie:
const items = ['a', 'b', 'c', 'd', 'e', ​​'f']
const removeItem = (objekt, i) =>
items.slice (0, i-1) .concat (items.slice (i, items.length))
låt filteredItems = removeItem (objekt, 3)
filteredItems = removeItem (filteredItems, 5)
// ["a", "b", "c", "d"]
console.log (filteredItems)
Efter värde
Du kan söka efter inkludering i återuppringningsfunktionen:
const items = ['a', 'b', 'c', 'd', 'e', ​​'f']
const valuesToRemove = ['c', 'd']
const filteredItems = items.filter (item =>! valuesToRemove.includes (item))
// ["a", "b", "e", "f"]
console.log (filteredItems)
Undvik att mutera den ursprungliga matrisen
splice () (får inte förväxlas med slice ()) muterar den ursprungliga matrisen och bör undvikas.
(ursprungligen publicerad på min webbplats https://flaviocopes.com/how-to-remove-item-from-array/)
|
Kolla in den här koden. Det fungerar i alla större webbläsare.
remove_item = funktion (arr, värde) {
var b = '';
för (b i arr) {
if (arr [b] === värde) {
arr.splice (b, 1);
ha sönder;
}
}
retur arr;
};
Ring den här funktionen
remove_item (array, värde);
|
ES6 & utan mutation: (oktober 2016)
const removeByIndex = (lista, index) =>
[
... list.slice (0, index),
... list.slice (index + 1)
];
output = removeByIndex ([33,22,11,44], 1) // => [33,11,44]
console.log (output)
|
Du kan använda lodash _.pull (mutera array), _.pullAt (mutera array) eller _.without (inte mutera array),
var array1 = ['a', 'b', 'c', 'd']
_.pull (array1, 'c')
console.log (array1) // ['a', 'b', 'd']
var array2 = ['e', 'f', 'g', 'h']
_.pullAt (array2, 0)
console.log (array2) // ['f', 'g', 'h']
var array3 = ['i', 'j', 'k', 'l']
var newArray = _.without (array3, 'i') // ['j', 'k', 'l']
console.log (array3) // ['i', 'j', 'k', 'l']
|
Att ta bort ett visst element / en sträng från en matris kan göras i en enfodrad:
theArray.splice (theArray.indexOf ("stringToRemoveFromArray"), 1);
var:
theArray: den matris du vill ta bort något särskilt från
stringToRemoveFromArray: strängen du vill ta bort och 1 är mängden element du vill ta bort.
NOTERA: Om "stringToRemoveFromArray" inte finns i din array kommer detta att ta bort det sista elementet i arrayen.
Det är alltid bra praxis att kontrollera om elementet finns i din matris först innan du tar bort det.
om (theArray.indexOf ("stringToRemoveFromArray")> = 0) {
theArray.splice (theArray.indexOf ("stringToRemoveFromArray"), 1);
}
Om du har tillgång till nyare Ecmascript-versioner på din klients datorer (VARNING, kanske inte fungerar på äldre stationer):
var array = ['1', '2', '3', '4', '5', '6']
var newArray = array.filter ((värde) => värde! = '3');
Där '3' är det värde du vill ta bort från matrisen.
Matrisen skulle då bli: ['1', '2', '4', '5', '6']
|
OK, till exempel har du matrisen nedan:
var num = [1, 2, 3, 4, 5];
Och vi vill ta bort nummer 4. Du kan helt enkelt använda koden nedan:
num.splice (num.indexOf (4), 1); // num blir [1, 2, 3, 5];
Om du återanvänder den här funktionen skriver du en återanvändningsfunktion som kommer att kopplas till den ursprungliga arrayfunktionen som nedan:
Array.prototype.remove = Array.prototype.remove || funktion (x) {
const i = this.indexOf (x);
om (i === - 1)
lämna tillbaka;
this.splice (i, 1); // num.remove (5) === [1, 2, 3];
}
Men vad sägs om du har nedanstående array i stället med några [5] i arrayen?
var num = [5, 6, 5, 4, 5, 1, 5];
Vi behöver en loop för att kontrollera dem alla, men ett enklare och mer effektivt sätt är att använda inbyggda JavaScript-funktioner, så vi skriver en funktion som använder ett filter som nedan istället:
const _removeValue = (arr, x) => arr.filter (n => n! == x);
// _ removeValue ([1, 2, 3, 4, 5, 5, 6, 5], 5) // Return [1, 2, 3, 4, 6]
Det finns också tredjepartsbibliotek som hjälper dig att göra detta, som Lodash eller Underscore. Mer information finns på lodash _.pull, _.pullAt eller _.without.
|
Prestanda
Idag (2019-12-09) genomför jag prestandatester på macOS v10.13.6 (High Sierra) för valda lösningar. Jag visar delete (A), men jag använder den inte i jämförelse med andra metoder, eftersom den lämnade tomt utrymme i matrisen.
Slutsatserna
den snabbaste lösningen är array.splice (C) (förutom Safari för små matriser där den har andra gången)
för stora matriser är array.slice + splice (H) den snabbaste oföränderliga lösningen för Firefox och Safari; Array.from (B) är snabbast i Chrome
muterbara lösningar är vanligtvis 1,5x-6x snabbare än oföränderliga
för små bord på Safari är förvånansvärt den muterbara lösningen (C) långsammare än den oföränderliga lösningen (G)
Detaljer
I tester tar jag bort mittelementet från arrayen på olika sätt. A, C-lösningarna är på plats. B-, D-, E-, F-, G-, H-lösningarna är oföränderliga.
Resultat för array med 10 element
I Chrome är array.splice (C) den snabbaste lösningen på plats. Array.filter (D) är den snabbaste oföränderliga lösningen. Den långsammaste är array.slice (F). Du kan utföra testet på din maskin här.
Resultat för array med 1.000.000 element
I Chrome är array.splice (C) den snabbaste lösningen på plats (borttagningen (C) är lika snabb - men den lämnade en tom plats i matrisen (så att den inte utför en fullständig borttagning)). Array.slice-splice (H) är den snabbaste oföränderliga lösningen. Det långsammaste är array.filter (D och E). Du kan utföra testet på din maskin här.
var a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
var log = (letter, array) => console.log (letter, array.join `,`);
funktion A (array) {
var index = array.indexOf (5);
ta bort array [index];
log ('A', array);
}
funktion B (array) {
var index = array.indexOf (5);
var arr = Array.from (array);
arr.splice (index, 1)
logg ('B', arr);
}
funktion C (array) {
var index = array.indexOf (5);
array.splice (index, 1);
log ('C', array);
}
funktion D (array) {
var arr = array.filter (item => item! == 5)
logg ('D', arr);
}
funktion E (array) {
var index = array.indexOf (5);
var arr = array.filter ((artikel, i) => i! == index)
logg ('E', arr);
}
funktion F (array) {
var index = array.indexOf (5);
var arr = array.slice (0, index) .concat (array.slice (index + 1))
logg ('F', arr);
}
funktion G (array) {
var index = array.indexOf (5);
var arr = [... array.slice (0, index), ... array.slice (index + 1)]
logg ('G', arr);
}
funktion H (matris) {
var index = array.indexOf (5);
var arr = array.slice (0);
arr.splice (index, 1);
logg ('H', arr);
}
A ([... a]);
B ([... a]);
C ([... a]);
D ([... a]);
E ([... a]);
Fa]);
G ([... a]);
Ha]);
Detta kodavsnitt presenterar endast koden som används i prestandatester - den utför inte själva testerna.
Jämförelse för webbläsare: Chrome v78.0.0, Safari v13.0.4 och Firefox v71.0.0
|
Jag är ganska ny på JavaScript och behövde den här funktionen. Jag skrev bara detta:
function removeFromArray (array, item, index) {
medan ((index = array.indexOf (artikel))> -1) {
array.splice (index, 1);
}
}
Sedan när jag vill använda den:
// Ställ in lite dummydata
var dummyObj = {namn: "meow"};
var dummyArray = [dummyObj, "item1", "item1", "item2"];
// Ta bort dummydata
ta bortFromArray (dummyArray, dummyObj);
removeFromArray (dummyArray, "item2");
Output - Som förväntat.
["item1", "item1"]
Du kan ha andra behov än jag, så du kan enkelt ändra detför att passa dem. Jag hoppas att det hjälper någon.
|
Om du har komplexa objekt i matrisen kan du använda filter?
I situationer där $ .inArray eller array.splice inte är lika lätt att använda. Speciellt om objekten kanske är grunda i matrisen.
T.ex. om du har ett objekt med ett Id-fält och du vill att objektet ska tas bort från en matris:
this.array = this.array.filter (funktion (element, i) {
returnera element.id! == idToRemove;
});
|
Jag vill svara baserat på ECMAScript 6. Antag att du har en matris som nedan:
låt arr = [1,2,3,4];
Om du vill radera vid ett specialindex som 2, skriv nedanstående kod:
arr.splice (2, 1); // => arr blev [1,2,4]
Men om du vill radera ett speciellt objekt som 3 och du inte känner till dess index, gör som nedan:
arr = arr.filter (e => e! == 3); // => arr blev [1,2,4]
Tips: använd en pilfunktion för återuppringning av filter såvida du inte får en tom matris.
|
Uppdatering: Den här metoden rekommenderas endast om du inte kan använda ECMAScript 2015 (tidigare känt som ES6). Om du kan använda det ger andra svar här mycket snyggare implementeringar.
Den här kärnan här löser ditt problem och raderar också alla förekomster av argumentet istället för bara 1 (eller ett angivet värde).
Array.prototype.destroy = funktion (obj) {
// Return null om inga objekt hittades och togs bort
var förstört = null;
för (var i = 0; i  3
x förstör (falskt); // => falskt
x; // => [1, 2, sant, odefinierad]
x.destroy (sant); // => sant
x förstör (odefinierad); // => odefinierad
x; // => [1, 2]
x förstör (3); // => null
x; // => [1, 2]
|
ES10-uppdatering
Detta inlägg sammanfattar vanliga tillvägagångssätt för att ta bort element från array från och med ECMAScript 2019 (ES10).
1. Allmänna ärenden
1.1. Ta bort matriselement med värde med .splice ()
| På plats: Ja |
| Tar bort dubbletter: Ja (loop), Nej (indexOf) |
| Efter värde / index: Efter index |
Om du vet vilket värde du vill ta bort från en matris kan du använda splitsningsmetoden. Först måste du identifiera indexet för målobjektet. Du använder sedan indexet som startelement och tar bort bara ett element.
// Med en "för" -slinga
const arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0];
för (låt i = 0; i  [1, 2, 3, 4, 6, 7, 8, 9, 0]
// Med .indexOf () -metoden
const arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0];
const i = arr.indexOf (5);
arr.splice (i, 1); // => [1, 2, 3, 4, 6, 7, 8, 9, 0]
1.2. Ta bort Array-element med metoden .filter ()
| På plats: Nej |
| Tar bort dubbletter: Ja |
| Efter värde / index: Efter värde |
Specifikt element kan filtreras bort från matrisen genom att tillhandahålla filtreringsfunktion. En sådan funktion kallas sedan för varje element i matrisen.
const-värde = 3
låt arr = [1, 2, 3, 4, 5, 3]
arr = arr.filter (artikel => artikel! == värde)
console.log (arr)
// [1, 2, 4, 5]
1.3. Ta bort Array-element genom att utöka Array.prototype
| På plats: Ja / Nej (Beror på implementering) |
| Tar bort dubbletter: Ja / Nej (Beror på implementering) |
| Efter värde / index: Efter index / Efter värde (Beror på implementering) |
Prototyp av Array kan utökas med ytterligare metoder. Sådana metoder är sedan tillgängliga att använda på skapade matriser.
Obs! Förlängning av prototyper av objekt från JavaScript-standardbiblioteket (som Array) betraktas av vissa som ett antipattern.
// På plats, tar bort alla, genom värdimplementering
Array.prototype.remove = funktion (artikel) {
för (låt i = 0; i  = ES10)
| På plats: Nej |
| Tar bort dubbletter: Ja |
| Efter värde / index: Efter värde |
ES10 introducerade Object.fromEntries, vilket kan varaanvänds för att skapa önskad matris från något arrayliknande objekt och filtrera oönskade element under processen.
konstobjekt = [1,2,3,4];
const valueToRemove = 3;
const arr = Object.values ​​(Object.fromEntries (
Object.entries (objekt)
.filter (([key, val]) => val! == valueToRemove)
));
console.log (arr); // [1,2,4]
2. Särskilda fall
2.1 Ta bort elementet om det är i slutet av matrisen
2.1.1. Ändrar matrislängd
| På plats: Ja |
| Tar bort dubbletter: Nej |
| Efter värde / index: Ej tillämpligt |
JavaScript Array-element kan tas bort från slutet av en array genom att ställa in egenskapen length till ett värde som är mindre än det aktuella värdet. Alla element vars index är större än eller lika med den nya längden tas bort.
const arr = [1, 2, 3, 4, 5, 6];
arrlängd = 5; // Ställ in längd för att ta bort elementet
console.log (arr); // [1, 2, 3, 4, 5]
2.1.2. Med .pop () -metoden
| På plats: Ja |
| Tar bort dubbletter: Nej |
| Efter värde / index: Ej tillämpligt |
Popmetoden tar bort det sista elementet i matrisen, returnerar det elementet och uppdaterar längdegenskapen. Popmetoden modifierar den matris som den anropas på. Detta innebär att till skillnad från att ta bort raderas det sista elementet helt och matrislängden minskas.
const arr = [1, 2, 3, 4, 5, 6];
arr.pop (); // returnerar 6
console.log (arr); // [1, 2, 3, 4, 5]
2.2. Ta bort elementet om det är i början av matrisen
| På plats: Ja |
| Tar bort dubbletter: Nej |
| Efter värde / index: Ej tillämpligt |
Metoden .shift () fungerar ungefär som popmetoden förutom att den tar bort det första elementet i en JavaScript-array i stället för det sista. När elementet tas bort flyttas de återstående elementen nedåt.
const arr = [1, 2, 3, 4];
arr.skift (); // returnerar 1
console.log (arr); // [2, 3, 4]
2.3. Ta bort elementet om det är det enda elementet i matrisen
| På plats: Ja |
| Tar bort dubbletter: N / A |
| Efter värde / index: Ej tillämpligt |
Den snabbaste tekniken är att ställa in en arrayvariabel till en tom array.
låt arr = [1];
arr = []; // tom matris
Alternativt kan teknik från 2.1.1 användas genom att ställa in längd till 0.
|
Du ska aldrig mutera din matris. Eftersom detta strider mot det funktionella programmeringsmönstret. Du kan skapa en ny matris utan att referera till den matris som du vill ändra data med ECMAScript 6-metodfiltret.
var myArray = [1, 2, 3, 4, 5, 6];
Antag att du vill ta bort 5 från matrisen, du kan helt enkelt göra det så här:
myArray = myArray.filter (värde => värde! == 5);
Detta ger dig en ny matris utan det värde du ville ta bort. Så resultatet blir:
[1, 2, 3, 4, 6]; // 5 har tagits bort från den här matrisen
För ytterligare förståelse kan du läsa MDN-dokumentationen på Array.filter.
|
Ett mer modernt ECMAScript 2015 (tidigare känt som Harmony eller ES 6). Given:
const items = [1, 2, 3, 4];
const index = 2;
Sedan:
items.filter ((x, i) => i! == index);
Avkastning:
[1, 2, 4]
Du kan använda Babel och en polyfill-tjänst för att säkerställa att detta stöds bra i alla webbläsare.
|
Du kan göra en bakåtslinga för att se till att inte skruva upp indexen, om det finns flera instanser av elementet.
var myElement = "choklad";
var myArray = ['choklad', 'poptart', 'poptart', 'poptart', 'choklad', 'poptart', 'poptart', 'choklad'];
/ * Viktig kod * /
för (var i = myArray.length - 1; i> = 0; i--) {
om (myArray [i] == myElement) myArray.splice (i, 1);
}
console.log (myArray);
Live-demo
|
Du har 1 till 9 i matrisen och du vill ta bort 5. Använd nedanstående kod:
var numberArray = [1, 2, 3, 4, 5, 6, 7, 8, 9];
var newNumberArray = numberArray.filter (m => {
returnera m! == 5;
});
console.log ("ny matris, 5 borttagen", newNumberArray);
Om du vill ha flera värden. Exempel: - 1,7,8
var numberArray = [1, 2, 3, 4, 5, 6, 7, 8, 9];
var newNumberArray = numberArray.filter (m => {
returnera (m! == 1) && (m! == 7) && (m! == 8);
});
console.log ("ny matris, 1,7 och 8 borttagen", newNumberArray);
Om du vill ta bort ett matrisvärde i en matris. Exempel: [3,4,5]
var numberArray = [1, 2, 3, 4, 5, 6, 7, 8, 9];
var removebleArray = [3,4,5];
var newNumberArray = numberArray.filter (m => {
returnera! removebleArray.includes (m);
});
console.log ("ny matris, [3,4,5] borttagen", newNumberArray);
Inkluderar webbläsare som stöds är länk.
|
1
2
3
4
Nästa
Mycket aktiv fråga. Tjäna 10 rykte för att svara på den här frågan. Kravet på rykte hjälper till att skydda denna fråga från skräppost och icke-svar-aktivitet.
Inte svaret du letar efter? Bläddra bland andra frågor taggade javascript arrays eller ställ din egen fråga.